home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / compiler / transformer.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  41.1 KB  |  1,499 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Parse tree transformation module.
  5.  
  6. Transforms Python source code into an abstract syntax tree (AST)
  7. defined in the ast module.
  8.  
  9. The simplest ways to invoke this module are via parse and parseFile.
  10. parse(buf) -> AST
  11. parseFile(path) -> AST
  12. '''
  13. from compiler.ast import *
  14. import parser
  15. import symbol
  16. import token
  17. import sys
  18.  
  19. class WalkerError(StandardError):
  20.     pass
  21.  
  22. from consts import CO_VARARGS, CO_VARKEYWORDS
  23. from consts import OP_ASSIGN, OP_DELETE, OP_APPLY
  24.  
  25. def parseFile(path):
  26.     f = open(path, 'U')
  27.     src = f.read() + '\n'
  28.     f.close()
  29.     return parse(src)
  30.  
  31.  
  32. def parse(buf, mode = 'exec'):
  33.     if mode == 'exec' or mode == 'single':
  34.         return Transformer().parsesuite(buf)
  35.     elif mode == 'eval':
  36.         return Transformer().parseexpr(buf)
  37.     else:
  38.         raise ValueError("compile() arg 3 must be 'exec' or 'eval' or 'single'")
  39.  
  40.  
  41. def asList(nodes):
  42.     l = []
  43.     for item in nodes:
  44.         if hasattr(item, 'asList'):
  45.             l.append(item.asList())
  46.             continue
  47.         if type(item) is type((None, None)):
  48.             l.append(tuple(asList(item)))
  49.             continue
  50.         if type(item) is type([]):
  51.             l.append(asList(item))
  52.             continue
  53.         l.append(item)
  54.     
  55.     return l
  56.  
  57.  
  58. def extractLineNo(ast):
  59.     if not isinstance(ast[1], tuple):
  60.         return ast[2]
  61.     
  62.     for child in ast[1:]:
  63.         if isinstance(child, tuple):
  64.             lineno = extractLineNo(child)
  65.             if lineno is not None:
  66.                 return lineno
  67.             
  68.         lineno is not None
  69.     
  70.  
  71.  
  72. def Node(*args):
  73.     kind = args[0]
  74.     if nodes.has_key(kind):
  75.         
  76.         try:
  77.             return nodes[kind](*args[1:])
  78.         except TypeError:
  79.             print nodes[kind], len(args), args
  80.             raise 
  81.         except:
  82.             None<EXCEPTION MATCH>TypeError
  83.         
  84.  
  85.     None<EXCEPTION MATCH>TypeError
  86.     raise WalkerError, "Can't find appropriate Node type: %s" % str(args)
  87.  
  88.  
  89. class Transformer:
  90.     '''Utility object for transforming Python parse trees.
  91.  
  92.     Exposes the following methods:
  93.         tree = transform(ast_tree)
  94.         tree = parsesuite(text)
  95.         tree = parseexpr(text)
  96.         tree = parsefile(fileob | filename)
  97.     '''
  98.     
  99.     def __init__(self):
  100.         self._dispatch = { }
  101.         for value, name in symbol.sym_name.items():
  102.             if hasattr(self, name):
  103.                 self._dispatch[value] = getattr(self, name)
  104.                 continue
  105.         
  106.         self._dispatch[token.NEWLINE] = self.com_NEWLINE
  107.         self._atom_dispatch = {
  108.             token.LPAR: self.atom_lpar,
  109.             token.LSQB: self.atom_lsqb,
  110.             token.LBRACE: self.atom_lbrace,
  111.             token.BACKQUOTE: self.atom_backquote,
  112.             token.NUMBER: self.atom_number,
  113.             token.STRING: self.atom_string,
  114.             token.NAME: self.atom_name }
  115.         self.encoding = None
  116.  
  117.     
  118.     def transform(self, tree):
  119.         '''Transform an AST into a modified parse tree.'''
  120.         if not isinstance(tree, tuple) or isinstance(tree, list):
  121.             tree = parser.ast2tuple(tree, line_info = 1)
  122.         
  123.         return self.compile_node(tree)
  124.  
  125.     
  126.     def parsesuite(self, text):
  127.         '''Return a modified parse tree for the given suite text.'''
  128.         return self.transform(parser.suite(text))
  129.  
  130.     
  131.     def parseexpr(self, text):
  132.         '''Return a modified parse tree for the given expression text.'''
  133.         return self.transform(parser.expr(text))
  134.  
  135.     
  136.     def parsefile(self, file):
  137.         '''Return a modified parse tree for the contents of the given file.'''
  138.         if type(file) == type(''):
  139.             file = open(file)
  140.         
  141.         return self.parsesuite(file.read())
  142.  
  143.     
  144.     def compile_node(self, node):
  145.         n = node[0]
  146.         if n == symbol.encoding_decl:
  147.             self.encoding = node[2]
  148.             node = node[1]
  149.             n = node[0]
  150.         
  151.         if n == symbol.single_input:
  152.             return self.single_input(node[1:])
  153.         
  154.         if n == symbol.file_input:
  155.             return self.file_input(node[1:])
  156.         
  157.         if n == symbol.eval_input:
  158.             return self.eval_input(node[1:])
  159.         
  160.         if n == symbol.lambdef:
  161.             return self.lambdef(node[1:])
  162.         
  163.         if n == symbol.funcdef:
  164.             return self.funcdef(node[1:])
  165.         
  166.         if n == symbol.classdef:
  167.             return self.classdef(node[1:])
  168.         
  169.         raise WalkerError, ('unexpected node type', n)
  170.  
  171.     
  172.     def single_input(self, node):
  173.         n = node[0][0]
  174.         if n != token.NEWLINE:
  175.             return self.com_stmt(node[0])
  176.         
  177.         return Pass()
  178.  
  179.     
  180.     def file_input(self, nodelist):
  181.         doc = self.get_docstring(nodelist, symbol.file_input)
  182.         if doc is not None:
  183.             i = 1
  184.         else:
  185.             i = 0
  186.         stmts = []
  187.         for node in nodelist[i:]:
  188.             if node[0] != token.ENDMARKER and node[0] != token.NEWLINE:
  189.                 self.com_append_stmt(stmts, node)
  190.                 continue
  191.         
  192.         return Module(doc, Stmt(stmts))
  193.  
  194.     
  195.     def eval_input(self, nodelist):
  196.         return Expression(self.com_node(nodelist[0]))
  197.  
  198.     
  199.     def decorator_name(self, nodelist):
  200.         listlen = len(nodelist)
  201.         if not listlen >= 1 or listlen % 2 == 1:
  202.             raise AssertionError
  203.         item = self.atom_name(nodelist)
  204.         i = 1
  205.         while i < listlen:
  206.             if not nodelist[i][0] == token.DOT:
  207.                 raise AssertionError
  208.             if not nodelist[i + 1][0] == token.NAME:
  209.                 raise AssertionError
  210.             item = Getattr(item, nodelist[i + 1][1])
  211.             i += 2
  212.         return item
  213.  
  214.     
  215.     def decorator(self, nodelist):
  216.         if not len(nodelist) in (3, 5, 6):
  217.             raise AssertionError
  218.         if not nodelist[0][0] == token.AT:
  219.             raise AssertionError
  220.         if not nodelist[-1][0] == token.NEWLINE:
  221.             raise AssertionError
  222.         if not nodelist[1][0] == symbol.dotted_name:
  223.             raise AssertionError
  224.         funcname = self.decorator_name(nodelist[1][1:])
  225.         if len(nodelist) > 3:
  226.             if not nodelist[2][0] == token.LPAR:
  227.                 raise AssertionError
  228.             expr = self.com_call_function(funcname, nodelist[3])
  229.         else:
  230.             expr = funcname
  231.         return expr
  232.  
  233.     
  234.     def decorators(self, nodelist):
  235.         items = []
  236.         for dec_nodelist in nodelist:
  237.             if not dec_nodelist[0] == symbol.decorator:
  238.                 raise AssertionError
  239.             items.append(self.decorator(dec_nodelist[1:]))
  240.         
  241.         return Decorators(items)
  242.  
  243.     
  244.     def funcdef(self, nodelist):
  245.         if len(nodelist) == 6:
  246.             if not nodelist[0][0] == symbol.decorators:
  247.                 raise AssertionError
  248.             decorators = self.decorators(nodelist[0][1:])
  249.         elif not len(nodelist) == 5:
  250.             raise AssertionError
  251.         decorators = None
  252.         lineno = nodelist[-4][2]
  253.         name = nodelist[-4][1]
  254.         args = nodelist[-3][2]
  255.         if args[0] == symbol.varargslist:
  256.             (names, defaults, flags) = self.com_arglist(args[1:])
  257.         else:
  258.             names = defaults = ()
  259.             flags = 0
  260.         doc = self.get_docstring(nodelist[-1])
  261.         code = self.com_node(nodelist[-1])
  262.         if doc is not None:
  263.             if not isinstance(code, Stmt):
  264.                 raise AssertionError
  265.             if not isinstance(code.nodes[0], Discard):
  266.                 raise AssertionError
  267.             del code.nodes[0]
  268.         
  269.         return Function(decorators, name, names, defaults, flags, doc, code, lineno = lineno)
  270.  
  271.     
  272.     def lambdef(self, nodelist):
  273.         if nodelist[2][0] == symbol.varargslist:
  274.             (names, defaults, flags) = self.com_arglist(nodelist[2][1:])
  275.         else:
  276.             names = defaults = ()
  277.             flags = 0
  278.         code = self.com_node(nodelist[-1])
  279.         return Lambda(names, defaults, flags, code, lineno = nodelist[1][2])
  280.  
  281.     
  282.     def classdef(self, nodelist):
  283.         name = nodelist[1][1]
  284.         doc = self.get_docstring(nodelist[-1])
  285.         if nodelist[2][0] == token.COLON:
  286.             bases = []
  287.         else:
  288.             bases = self.com_bases(nodelist[3])
  289.         code = self.com_node(nodelist[-1])
  290.         if doc is not None:
  291.             if not isinstance(code, Stmt):
  292.                 raise AssertionError
  293.             if not isinstance(code.nodes[0], Discard):
  294.                 raise AssertionError
  295.             del code.nodes[0]
  296.         
  297.         return Class(name, bases, doc, code, lineno = nodelist[1][2])
  298.  
  299.     
  300.     def stmt(self, nodelist):
  301.         return self.com_stmt(nodelist[0])
  302.  
  303.     small_stmt = stmt
  304.     flow_stmt = stmt
  305.     compound_stmt = stmt
  306.     
  307.     def simple_stmt(self, nodelist):
  308.         stmts = []
  309.         for i in range(0, len(nodelist), 2):
  310.             self.com_append_stmt(stmts, nodelist[i])
  311.         
  312.         return Stmt(stmts)
  313.  
  314.     
  315.     def parameters(self, nodelist):
  316.         raise WalkerError
  317.  
  318.     
  319.     def varargslist(self, nodelist):
  320.         raise WalkerError
  321.  
  322.     
  323.     def fpdef(self, nodelist):
  324.         raise WalkerError
  325.  
  326.     
  327.     def fplist(self, nodelist):
  328.         raise WalkerError
  329.  
  330.     
  331.     def dotted_name(self, nodelist):
  332.         raise WalkerError
  333.  
  334.     
  335.     def comp_op(self, nodelist):
  336.         raise WalkerError
  337.  
  338.     
  339.     def trailer(self, nodelist):
  340.         raise WalkerError
  341.  
  342.     
  343.     def sliceop(self, nodelist):
  344.         raise WalkerError
  345.  
  346.     
  347.     def argument(self, nodelist):
  348.         raise WalkerError
  349.  
  350.     
  351.     def expr_stmt(self, nodelist):
  352.         en = nodelist[-1]
  353.         exprNode = self.lookup_node(en)(en[1:])
  354.         if len(nodelist) == 1:
  355.             return Discard(exprNode, lineno = exprNode.lineno)
  356.         
  357.         if nodelist[1][0] == token.EQUAL:
  358.             nodesl = []
  359.             for i in range(0, len(nodelist) - 2, 2):
  360.                 nodesl.append(self.com_assign(nodelist[i], OP_ASSIGN))
  361.             
  362.             return Assign(nodesl, exprNode, lineno = nodelist[1][2])
  363.         else:
  364.             lval = self.com_augassign(nodelist[0])
  365.             op = self.com_augassign_op(nodelist[1])
  366.             return AugAssign(lval, op[1], exprNode, lineno = op[2])
  367.         raise WalkerError, "can't get here"
  368.  
  369.     
  370.     def print_stmt(self, nodelist):
  371.         items = []
  372.         if len(nodelist) == 1:
  373.             start = 1
  374.             dest = None
  375.         elif nodelist[1][0] == token.RIGHTSHIFT:
  376.             if not len(nodelist) == 3 and nodelist[3][0] == token.COMMA:
  377.                 raise AssertionError
  378.             dest = self.com_node(nodelist[2])
  379.             start = 4
  380.         else:
  381.             dest = None
  382.             start = 1
  383.         for i in range(start, len(nodelist), 2):
  384.             items.append(self.com_node(nodelist[i]))
  385.         
  386.         if nodelist[-1][0] == token.COMMA:
  387.             return Print(items, dest, lineno = nodelist[0][2])
  388.         
  389.         return Printnl(items, dest, lineno = nodelist[0][2])
  390.  
  391.     
  392.     def del_stmt(self, nodelist):
  393.         return self.com_assign(nodelist[1], OP_DELETE)
  394.  
  395.     
  396.     def pass_stmt(self, nodelist):
  397.         return Pass(lineno = nodelist[0][2])
  398.  
  399.     
  400.     def break_stmt(self, nodelist):
  401.         return Break(lineno = nodelist[0][2])
  402.  
  403.     
  404.     def continue_stmt(self, nodelist):
  405.         return Continue(lineno = nodelist[0][2])
  406.  
  407.     
  408.     def return_stmt(self, nodelist):
  409.         if len(nodelist) < 2:
  410.             return Return(Const(None), lineno = nodelist[0][2])
  411.         
  412.         return Return(self.com_node(nodelist[1]), lineno = nodelist[0][2])
  413.  
  414.     
  415.     def yield_stmt(self, nodelist):
  416.         return Yield(self.com_node(nodelist[1]), lineno = nodelist[0][2])
  417.  
  418.     
  419.     def raise_stmt(self, nodelist):
  420.         if len(nodelist) > 5:
  421.             expr3 = self.com_node(nodelist[5])
  422.         else:
  423.             expr3 = None
  424.         if len(nodelist) > 3:
  425.             expr2 = self.com_node(nodelist[3])
  426.         else:
  427.             expr2 = None
  428.         if len(nodelist) > 1:
  429.             expr1 = self.com_node(nodelist[1])
  430.         else:
  431.             expr1 = None
  432.         return Raise(expr1, expr2, expr3, lineno = nodelist[0][2])
  433.  
  434.     
  435.     def import_stmt(self, nodelist):
  436.         if not len(nodelist) == 1:
  437.             raise AssertionError
  438.         return self.com_node(nodelist[0])
  439.  
  440.     
  441.     def import_name(self, nodelist):
  442.         return Import(self.com_dotted_as_names(nodelist[1]), lineno = nodelist[0][2])
  443.  
  444.     
  445.     def import_from(self, nodelist):
  446.         if not nodelist[0][1] == 'from':
  447.             raise AssertionError
  448.         if not nodelist[1][0] == symbol.dotted_name:
  449.             raise AssertionError
  450.         if not nodelist[2][1] == 'import':
  451.             raise AssertionError
  452.         fromname = self.com_dotted_name(nodelist[1])
  453.         if nodelist[3][0] == token.STAR:
  454.             return From(fromname, [
  455.                 ('*', None)], lineno = nodelist[0][2])
  456.         else:
  457.             node = nodelist[3 + (nodelist[3][0] == token.LPAR)]
  458.             return From(fromname, self.com_import_as_names(node), lineno = nodelist[0][2])
  459.  
  460.     
  461.     def global_stmt(self, nodelist):
  462.         names = []
  463.         for i in range(1, len(nodelist), 2):
  464.             names.append(nodelist[i][1])
  465.         
  466.         return Global(names, lineno = nodelist[0][2])
  467.  
  468.     
  469.     def exec_stmt(self, nodelist):
  470.         expr1 = self.com_node(nodelist[1])
  471.         if len(nodelist) >= 4:
  472.             expr2 = self.com_node(nodelist[3])
  473.             if len(nodelist) >= 6:
  474.                 expr3 = self.com_node(nodelist[5])
  475.             else:
  476.                 expr3 = None
  477.         else:
  478.             expr2 = None
  479.             expr3 = None
  480.         return Exec(expr1, expr2, expr3, lineno = nodelist[0][2])
  481.  
  482.     
  483.     def assert_stmt(self, nodelist):
  484.         expr1 = self.com_node(nodelist[1])
  485.         if len(nodelist) == 4:
  486.             expr2 = self.com_node(nodelist[3])
  487.         else:
  488.             expr2 = None
  489.         return Assert(expr1, expr2, lineno = nodelist[0][2])
  490.  
  491.     
  492.     def if_stmt(self, nodelist):
  493.         tests = []
  494.         for i in range(0, len(nodelist) - 3, 4):
  495.             testNode = self.com_node(nodelist[i + 1])
  496.             suiteNode = self.com_node(nodelist[i + 3])
  497.             tests.append((testNode, suiteNode))
  498.         
  499.         if len(nodelist) % 4 == 3:
  500.             elseNode = self.com_node(nodelist[-1])
  501.         else:
  502.             elseNode = None
  503.         return If(tests, elseNode, lineno = nodelist[0][2])
  504.  
  505.     
  506.     def while_stmt(self, nodelist):
  507.         testNode = self.com_node(nodelist[1])
  508.         bodyNode = self.com_node(nodelist[3])
  509.         if len(nodelist) > 4:
  510.             elseNode = self.com_node(nodelist[6])
  511.         else:
  512.             elseNode = None
  513.         return While(testNode, bodyNode, elseNode, lineno = nodelist[0][2])
  514.  
  515.     
  516.     def for_stmt(self, nodelist):
  517.         assignNode = self.com_assign(nodelist[1], OP_ASSIGN)
  518.         listNode = self.com_node(nodelist[3])
  519.         bodyNode = self.com_node(nodelist[5])
  520.         if len(nodelist) > 8:
  521.             elseNode = self.com_node(nodelist[8])
  522.         else:
  523.             elseNode = None
  524.         return For(assignNode, listNode, bodyNode, elseNode, lineno = nodelist[0][2])
  525.  
  526.     
  527.     def try_stmt(self, nodelist):
  528.         if nodelist[3][0] != symbol.except_clause:
  529.             return self.com_try_finally(nodelist)
  530.         
  531.         return self.com_try_except(nodelist)
  532.  
  533.     
  534.     def suite(self, nodelist):
  535.         if len(nodelist) == 1:
  536.             return self.com_stmt(nodelist[0])
  537.         
  538.         stmts = []
  539.         for node in nodelist:
  540.             if node[0] == symbol.stmt:
  541.                 self.com_append_stmt(stmts, node)
  542.                 continue
  543.         
  544.         return Stmt(stmts)
  545.  
  546.     
  547.     def testlist(self, nodelist):
  548.         return self.com_binary(Tuple, nodelist)
  549.  
  550.     testlist_safe = testlist
  551.     testlist1 = testlist
  552.     exprlist = testlist
  553.     
  554.     def testlist_gexp(self, nodelist):
  555.         if len(nodelist) == 2 and nodelist[1][0] == symbol.gen_for:
  556.             test = self.com_node(nodelist[0])
  557.             return self.com_generator_expression(test, nodelist[1])
  558.         
  559.         return self.testlist(nodelist)
  560.  
  561.     
  562.     def test(self, nodelist):
  563.         if len(nodelist) == 1 and nodelist[0][0] == symbol.lambdef:
  564.             return self.lambdef(nodelist[0])
  565.         
  566.         return self.com_binary(Or, nodelist)
  567.  
  568.     
  569.     def and_test(self, nodelist):
  570.         return self.com_binary(And, nodelist)
  571.  
  572.     
  573.     def not_test(self, nodelist):
  574.         result = self.com_node(nodelist[-1])
  575.         if len(nodelist) == 2:
  576.             return Not(result, lineno = nodelist[0][2])
  577.         
  578.         return result
  579.  
  580.     
  581.     def comparison(self, nodelist):
  582.         node = self.com_node(nodelist[0])
  583.         if len(nodelist) == 1:
  584.             return node
  585.         
  586.         results = []
  587.         for i in range(2, len(nodelist), 2):
  588.             nl = nodelist[i - 1]
  589.             n = nl[1]
  590.             if n[0] == token.NAME:
  591.                 type = n[1]
  592.                 if len(nl) == 3:
  593.                     if type == 'not':
  594.                         type = 'not in'
  595.                     else:
  596.                         type = 'is not'
  597.                 
  598.             else:
  599.                 type = _cmp_types[n[0]]
  600.             lineno = nl[1][2]
  601.             results.append((type, self.com_node(nodelist[i])))
  602.         
  603.         return Compare(node, results, lineno = lineno)
  604.  
  605.     
  606.     def expr(self, nodelist):
  607.         return self.com_binary(Bitor, nodelist)
  608.  
  609.     
  610.     def xor_expr(self, nodelist):
  611.         return self.com_binary(Bitxor, nodelist)
  612.  
  613.     
  614.     def and_expr(self, nodelist):
  615.         return self.com_binary(Bitand, nodelist)
  616.  
  617.     
  618.     def shift_expr(self, nodelist):
  619.         node = self.com_node(nodelist[0])
  620.         for i in range(2, len(nodelist), 2):
  621.             right = self.com_node(nodelist[i])
  622.             if nodelist[i - 1][0] == token.LEFTSHIFT:
  623.                 node = LeftShift([
  624.                     node,
  625.                     right], lineno = nodelist[1][2])
  626.                 continue
  627.             if nodelist[i - 1][0] == token.RIGHTSHIFT:
  628.                 node = RightShift([
  629.                     node,
  630.                     right], lineno = nodelist[1][2])
  631.                 continue
  632.             raise ValueError, 'unexpected token: %s' % nodelist[i - 1][0]
  633.         
  634.         return node
  635.  
  636.     
  637.     def arith_expr(self, nodelist):
  638.         node = self.com_node(nodelist[0])
  639.         for i in range(2, len(nodelist), 2):
  640.             right = self.com_node(nodelist[i])
  641.             if nodelist[i - 1][0] == token.PLUS:
  642.                 node = Add([
  643.                     node,
  644.                     right], lineno = nodelist[1][2])
  645.                 continue
  646.             if nodelist[i - 1][0] == token.MINUS:
  647.                 node = Sub([
  648.                     node,
  649.                     right], lineno = nodelist[1][2])
  650.                 continue
  651.             raise ValueError, 'unexpected token: %s' % nodelist[i - 1][0]
  652.         
  653.         return node
  654.  
  655.     
  656.     def term(self, nodelist):
  657.         node = self.com_node(nodelist[0])
  658.         for i in range(2, len(nodelist), 2):
  659.             right = self.com_node(nodelist[i])
  660.             t = nodelist[i - 1][0]
  661.             if t == token.STAR:
  662.                 node = Mul([
  663.                     node,
  664.                     right])
  665.             elif t == token.SLASH:
  666.                 node = Div([
  667.                     node,
  668.                     right])
  669.             elif t == token.PERCENT:
  670.                 node = Mod([
  671.                     node,
  672.                     right])
  673.             elif t == token.DOUBLESLASH:
  674.                 node = FloorDiv([
  675.                     node,
  676.                     right])
  677.             else:
  678.                 raise ValueError, 'unexpected token: %s' % t
  679.             node.lineno = nodelist[1][2]
  680.         
  681.         return node
  682.  
  683.     
  684.     def factor(self, nodelist):
  685.         elt = nodelist[0]
  686.         t = elt[0]
  687.         node = self.lookup_node(nodelist[-1])(nodelist[-1][1:])
  688.         if t == token.PLUS:
  689.             return UnaryAdd(node, lineno = elt[2])
  690.         elif t == token.MINUS:
  691.             return UnarySub(node, lineno = elt[2])
  692.         elif t == token.TILDE:
  693.             node = Invert(node, lineno = elt[2])
  694.         
  695.         return node
  696.  
  697.     
  698.     def power(self, nodelist):
  699.         node = self.com_node(nodelist[0])
  700.         for i in range(1, len(nodelist)):
  701.             elt = nodelist[i]
  702.             if elt[0] == token.DOUBLESTAR:
  703.                 return Power([
  704.                     node,
  705.                     self.com_node(nodelist[i + 1])], lineno = elt[2])
  706.             
  707.             node = self.com_apply_trailer(node, elt)
  708.         
  709.         return node
  710.  
  711.     
  712.     def atom(self, nodelist):
  713.         return self._atom_dispatch[nodelist[0][0]](nodelist)
  714.         n.lineno = nodelist[0][2]
  715.         return n
  716.  
  717.     
  718.     def atom_lpar(self, nodelist):
  719.         if nodelist[1][0] == token.RPAR:
  720.             return Tuple(())
  721.         
  722.         return self.com_node(nodelist[1])
  723.  
  724.     
  725.     def atom_lsqb(self, nodelist):
  726.         if nodelist[1][0] == token.RSQB:
  727.             return List(())
  728.         
  729.         return self.com_list_constructor(nodelist[1])
  730.  
  731.     
  732.     def atom_lbrace(self, nodelist):
  733.         if nodelist[1][0] == token.RBRACE:
  734.             return Dict(())
  735.         
  736.         return self.com_dictmaker(nodelist[1])
  737.  
  738.     
  739.     def atom_backquote(self, nodelist):
  740.         return Backquote(self.com_node(nodelist[1]))
  741.  
  742.     
  743.     def atom_number(self, nodelist):
  744.         k = eval(nodelist[0][1])
  745.         return Const(k, lineno = nodelist[0][2])
  746.  
  747.     
  748.     def decode_literal(self, lit):
  749.         if self.encoding:
  750.             if self.encoding not in [
  751.                 'utf-8',
  752.                 'iso-8859-1']:
  753.                 lit = unicode(lit, 'utf-8').encode(self.encoding)
  754.             
  755.             return eval('# coding: %s\n%s' % (self.encoding, lit))
  756.         else:
  757.             return eval(lit)
  758.  
  759.     
  760.     def atom_string(self, nodelist):
  761.         k = ''
  762.         for node in nodelist:
  763.             k += self.decode_literal(node[1])
  764.         
  765.         return Const(k, lineno = nodelist[0][2])
  766.  
  767.     
  768.     def atom_name(self, nodelist):
  769.         return Name(nodelist[0][1], lineno = nodelist[0][2])
  770.  
  771.     
  772.     def lookup_node(self, node):
  773.         return self._dispatch[node[0]]
  774.  
  775.     _callers = { }
  776.     
  777.     def com_node(self, node):
  778.         return self._dispatch[node[0]](node[1:])
  779.  
  780.     
  781.     def com_NEWLINE(self, *args):
  782.         return Discard(Const(None))
  783.  
  784.     
  785.     def com_arglist(self, nodelist):
  786.         names = []
  787.         defaults = []
  788.         flags = 0
  789.         i = 0
  790.         while i < len(nodelist):
  791.             node = nodelist[i]
  792.             if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
  793.                 if node[0] == token.STAR:
  794.                     node = nodelist[i + 1]
  795.                     if node[0] == token.NAME:
  796.                         names.append(node[1])
  797.                         flags = flags | CO_VARARGS
  798.                         i = i + 3
  799.                     
  800.                 
  801.                 if i < len(nodelist):
  802.                     t = nodelist[i][0]
  803.                     if t == token.DOUBLESTAR:
  804.                         node = nodelist[i + 1]
  805.                     else:
  806.                         raise ValueError, 'unexpected token: %s' % t
  807.                     names.append(node[1])
  808.                     flags = flags | CO_VARKEYWORDS
  809.                 
  810.                 break
  811.             
  812.             names.append(self.com_fpdef(node))
  813.             i = i + 1
  814.             if i >= len(nodelist):
  815.                 break
  816.             
  817.             if nodelist[i][0] == token.EQUAL:
  818.                 defaults.append(self.com_node(nodelist[i + 1]))
  819.                 i = i + 2
  820.             elif len(defaults):
  821.                 defaults.append(Const(None))
  822.             
  823.             i = i + 1
  824.         return (names, defaults, flags)
  825.  
  826.     
  827.     def com_fpdef(self, node):
  828.         if node[1][0] == token.LPAR:
  829.             return self.com_fplist(node[2])
  830.         
  831.         return node[1][1]
  832.  
  833.     
  834.     def com_fplist(self, node):
  835.         if len(node) == 2:
  836.             return self.com_fpdef(node[1])
  837.         
  838.         list = []
  839.         for i in range(1, len(node), 2):
  840.             list.append(self.com_fpdef(node[i]))
  841.         
  842.         return tuple(list)
  843.  
  844.     
  845.     def com_dotted_name(self, node):
  846.         name = ''
  847.         for n in node:
  848.             if type(n) == type(()) and n[0] == 1:
  849.                 name = name + n[1] + '.'
  850.                 continue
  851.         
  852.         return name[:-1]
  853.  
  854.     
  855.     def com_dotted_as_name(self, node):
  856.         if not node[0] == symbol.dotted_as_name:
  857.             raise AssertionError
  858.         node = node[1:]
  859.         dot = self.com_dotted_name(node[0][1:])
  860.         if len(node) == 1:
  861.             return (dot, None)
  862.         
  863.         if not node[1][1] == 'as':
  864.             raise AssertionError
  865.         if not node[2][0] == token.NAME:
  866.             raise AssertionError
  867.         return (dot, node[2][1])
  868.  
  869.     
  870.     def com_dotted_as_names(self, node):
  871.         if not node[0] == symbol.dotted_as_names:
  872.             raise AssertionError
  873.         node = node[1:]
  874.         names = [
  875.             self.com_dotted_as_name(node[0])]
  876.         for i in range(2, len(node), 2):
  877.             names.append(self.com_dotted_as_name(node[i]))
  878.         
  879.         return names
  880.  
  881.     
  882.     def com_import_as_name(self, node):
  883.         if not node[0] == symbol.import_as_name:
  884.             raise AssertionError
  885.         node = node[1:]
  886.         if not node[0][0] == token.NAME:
  887.             raise AssertionError
  888.         if len(node) == 1:
  889.             return (node[0][1], None)
  890.         
  891.         if not node[1][1] == 'as':
  892.             raise AssertionError, node
  893.         if not node[2][0] == token.NAME:
  894.             raise AssertionError
  895.         return (node[0][1], node[2][1])
  896.  
  897.     
  898.     def com_import_as_names(self, node):
  899.         if not node[0] == symbol.import_as_names:
  900.             raise AssertionError
  901.         node = node[1:]
  902.         names = [
  903.             self.com_import_as_name(node[0])]
  904.         for i in range(2, len(node), 2):
  905.             names.append(self.com_import_as_name(node[i]))
  906.         
  907.         return names
  908.  
  909.     
  910.     def com_bases(self, node):
  911.         bases = []
  912.         for i in range(1, len(node), 2):
  913.             bases.append(self.com_node(node[i]))
  914.         
  915.         return bases
  916.  
  917.     
  918.     def com_try_finally(self, nodelist):
  919.         return TryFinally(self.com_node(nodelist[2]), self.com_node(nodelist[5]), lineno = nodelist[0][2])
  920.  
  921.     
  922.     def com_try_except(self, nodelist):
  923.         stmt = self.com_node(nodelist[2])
  924.         clauses = []
  925.         elseNode = None
  926.         for i in range(3, len(nodelist), 3):
  927.             node = nodelist[i]
  928.             if node[0] == symbol.except_clause:
  929.                 if len(node) > 2:
  930.                     expr1 = self.com_node(node[2])
  931.                     if len(node) > 4:
  932.                         expr2 = self.com_assign(node[4], OP_ASSIGN)
  933.                     else:
  934.                         expr2 = None
  935.                 else:
  936.                     expr1 = None
  937.                     expr2 = None
  938.                 clauses.append((expr1, expr2, self.com_node(nodelist[i + 2])))
  939.             
  940.             if node[0] == token.NAME:
  941.                 elseNode = self.com_node(nodelist[i + 2])
  942.                 continue
  943.         
  944.         return TryExcept(self.com_node(nodelist[2]), clauses, elseNode, lineno = nodelist[0][2])
  945.  
  946.     
  947.     def com_augassign_op(self, node):
  948.         if not node[0] == symbol.augassign:
  949.             raise AssertionError
  950.         return node[1]
  951.  
  952.     
  953.     def com_augassign(self, node):
  954.         '''Return node suitable for lvalue of augmented assignment
  955.  
  956.         Names, slices, and attributes are the only allowable nodes.
  957.         '''
  958.         l = self.com_node(node)
  959.         if l.__class__ in (Name, Slice, Subscript, Getattr):
  960.             return l
  961.         
  962.         raise SyntaxError, "can't assign to %s" % l.__class__.__name__
  963.  
  964.     
  965.     def com_assign(self, node, assigning):
  966.         while None:
  967.             t = node[0]
  968.             if t == symbol.exprlist and t == symbol.testlist or t == symbol.testlist_gexp:
  969.                 if len(node) > 2:
  970.                     return self.com_assign_tuple(node, assigning)
  971.                 
  972.                 node = node[1]
  973.                 continue
  974.             if t in _assign_types:
  975.                 if len(node) > 2:
  976.                     raise SyntaxError, "can't assign to operator"
  977.                 
  978.                 node = node[1]
  979.                 continue
  980.             if t == symbol.power:
  981.                 if node[1][0] != symbol.atom:
  982.                     raise SyntaxError, "can't assign to operator"
  983.                 
  984.                 if len(node) > 2:
  985.                     primary = self.com_node(node[1])
  986.                     for i in range(2, len(node) - 1):
  987.                         ch = node[i]
  988.                         if ch[0] == token.DOUBLESTAR:
  989.                             raise SyntaxError, "can't assign to operator"
  990.                         
  991.                         primary = self.com_apply_trailer(primary, ch)
  992.                     
  993.                     return self.com_assign_trailer(primary, node[-1], assigning)
  994.                 
  995.                 node = node[1]
  996.                 continue
  997.             if t == symbol.atom:
  998.                 t = node[1][0]
  999.                 if t == token.LPAR:
  1000.                     node = node[2]
  1001.                     if node[0] == token.RPAR:
  1002.                         raise SyntaxError, "can't assign to ()"
  1003.                     
  1004.                 elif t == token.LSQB:
  1005.                     node = node[2]
  1006.                     if node[0] == token.RSQB:
  1007.                         raise SyntaxError, "can't assign to []"
  1008.                     
  1009.                     return self.com_assign_list(node, assigning)
  1010.                 elif t == token.NAME:
  1011.                     return self.com_assign_name(node[1], assigning)
  1012.                 else:
  1013.                     raise SyntaxError, "can't assign to literal"
  1014.             t == token.LPAR
  1015.             raise SyntaxError, 'bad assignment'
  1016.  
  1017.     
  1018.     def com_assign_tuple(self, node, assigning):
  1019.         assigns = []
  1020.         for i in range(1, len(node), 2):
  1021.             assigns.append(self.com_assign(node[i], assigning))
  1022.         
  1023.         return AssTuple(assigns, lineno = extractLineNo(node))
  1024.  
  1025.     
  1026.     def com_assign_list(self, node, assigning):
  1027.         assigns = []
  1028.         for i in range(1, len(node), 2):
  1029.             if i + 1 < len(node):
  1030.                 if node[i + 1][0] == symbol.list_for:
  1031.                     raise SyntaxError, "can't assign to list comprehension"
  1032.                 
  1033.                 if not node[i + 1][0] == token.COMMA:
  1034.                     raise AssertionError, node[i + 1]
  1035.             
  1036.             assigns.append(self.com_assign(node[i], assigning))
  1037.         
  1038.         return AssList(assigns, lineno = extractLineNo(node))
  1039.  
  1040.     
  1041.     def com_assign_name(self, node, assigning):
  1042.         return AssName(node[1], assigning, lineno = node[2])
  1043.  
  1044.     
  1045.     def com_assign_trailer(self, primary, node, assigning):
  1046.         t = node[1][0]
  1047.         if t == token.DOT:
  1048.             return self.com_assign_attr(primary, node[2], assigning)
  1049.         
  1050.         if t == token.LSQB:
  1051.             return self.com_subscriptlist(primary, node[2], assigning)
  1052.         
  1053.         if t == token.LPAR:
  1054.             raise SyntaxError, "can't assign to function call"
  1055.         
  1056.         raise SyntaxError, 'unknown trailer type: %s' % t
  1057.  
  1058.     
  1059.     def com_assign_attr(self, primary, node, assigning):
  1060.         return AssAttr(primary, node[1], assigning, lineno = node[-1])
  1061.  
  1062.     
  1063.     def com_binary(self, constructor, nodelist):
  1064.         """Compile 'NODE (OP NODE)*' into (type, [ node1, ..., nodeN ])."""
  1065.         l = len(nodelist)
  1066.         if l == 1:
  1067.             n = nodelist[0]
  1068.             return self.lookup_node(n)(n[1:])
  1069.         
  1070.         items = []
  1071.         for i in range(0, l, 2):
  1072.             n = nodelist[i]
  1073.             items.append(self.lookup_node(n)(n[1:]))
  1074.         
  1075.         return constructor(items, lineno = extractLineNo(nodelist))
  1076.  
  1077.     
  1078.     def com_stmt(self, node):
  1079.         result = self.lookup_node(node)(node[1:])
  1080.         if not result is not None:
  1081.             raise AssertionError
  1082.         if isinstance(result, Stmt):
  1083.             return result
  1084.         
  1085.         return Stmt([
  1086.             result])
  1087.  
  1088.     
  1089.     def com_append_stmt(self, stmts, node):
  1090.         result = self.lookup_node(node)(node[1:])
  1091.         if not result is not None:
  1092.             raise AssertionError
  1093.         if isinstance(result, Stmt):
  1094.             stmts.extend(result.nodes)
  1095.         else:
  1096.             stmts.append(result)
  1097.  
  1098.     if hasattr(symbol, 'list_for'):
  1099.         
  1100.         def com_list_constructor(self, nodelist):
  1101.             values = []
  1102.             for i in range(1, len(nodelist)):
  1103.                 if nodelist[i][0] == symbol.list_for:
  1104.                     if not len(nodelist[i:]) == 1:
  1105.                         raise AssertionError
  1106.                     return self.com_list_comprehension(values[0], nodelist[i])
  1107.                 elif nodelist[i][0] == token.COMMA:
  1108.                     continue
  1109.                 
  1110.                 values.append(self.com_node(nodelist[i]))
  1111.             
  1112.             return List(values, lineno = values[0].lineno)
  1113.  
  1114.         
  1115.         def com_list_comprehension(self, expr, node):
  1116.             lineno = node[1][2]
  1117.             fors = []
  1118.             while node:
  1119.                 t = node[1][1]
  1120.                 if t == 'for':
  1121.                     assignNode = self.com_assign(node[2], OP_ASSIGN)
  1122.                     listNode = self.com_node(node[4])
  1123.                     newfor = ListCompFor(assignNode, listNode, [])
  1124.                     newfor.lineno = node[1][2]
  1125.                     fors.append(newfor)
  1126.                     if len(node) == 5:
  1127.                         node = None
  1128.                     else:
  1129.                         node = self.com_list_iter(node[5])
  1130.                 len(node) == 5
  1131.                 if t == 'if':
  1132.                     test = self.com_node(node[2])
  1133.                     newif = ListCompIf(test, lineno = node[1][2])
  1134.                     newfor.ifs.append(newif)
  1135.                     if len(node) == 3:
  1136.                         node = None
  1137.                     else:
  1138.                         node = self.com_list_iter(node[3])
  1139.                 len(node) == 3
  1140.                 raise SyntaxError, 'unexpected list comprehension element: %s %d' % (node, lineno)
  1141.             return ListComp(expr, fors, lineno = lineno)
  1142.  
  1143.         
  1144.         def com_list_iter(self, node):
  1145.             if not node[0] == symbol.list_iter:
  1146.                 raise AssertionError
  1147.             return node[1]
  1148.  
  1149.     else:
  1150.         
  1151.         def com_list_constructor(self, nodelist):
  1152.             values = []
  1153.             for i in range(1, len(nodelist), 2):
  1154.                 values.append(self.com_node(nodelist[i]))
  1155.             
  1156.             return List(values)
  1157.  
  1158.     if hasattr(symbol, 'gen_for'):
  1159.         
  1160.         def com_generator_expression(self, expr, node):
  1161.             lineno = node[1][2]
  1162.             fors = []
  1163.             while node:
  1164.                 t = node[1][1]
  1165.                 if t == 'for':
  1166.                     assignNode = self.com_assign(node[2], OP_ASSIGN)
  1167.                     genNode = self.com_node(node[4])
  1168.                     newfor = GenExprFor(assignNode, genNode, [], lineno = node[1][2])
  1169.                     fors.append(newfor)
  1170.                     if len(node) == 5:
  1171.                         node = None
  1172.                     else:
  1173.                         node = self.com_gen_iter(node[5])
  1174.                 len(node) == 5
  1175.                 if t == 'if':
  1176.                     test = self.com_node(node[2])
  1177.                     newif = GenExprIf(test, lineno = node[1][2])
  1178.                     newfor.ifs.append(newif)
  1179.                     if len(node) == 3:
  1180.                         node = None
  1181.                     else:
  1182.                         node = self.com_gen_iter(node[3])
  1183.                 len(node) == 3
  1184.                 raise SyntaxError, 'unexpected generator expression element: %s %d' % (node, lineno)
  1185.             fors[0].is_outmost = True
  1186.             return GenExpr(GenExprInner(expr, fors), lineno = lineno)
  1187.  
  1188.         
  1189.         def com_gen_iter(self, node):
  1190.             if not node[0] == symbol.gen_iter:
  1191.                 raise AssertionError
  1192.             return node[1]
  1193.  
  1194.     
  1195.     
  1196.     def com_dictmaker(self, nodelist):
  1197.         items = []
  1198.         for i in range(1, len(nodelist), 4):
  1199.             items.append((self.com_node(nodelist[i]), self.com_node(nodelist[i + 2])))
  1200.         
  1201.         return Dict(items)
  1202.  
  1203.     
  1204.     def com_apply_trailer(self, primaryNode, nodelist):
  1205.         t = nodelist[1][0]
  1206.         if t == token.LPAR:
  1207.             return self.com_call_function(primaryNode, nodelist[2])
  1208.         
  1209.         if t == token.DOT:
  1210.             return self.com_select_member(primaryNode, nodelist[2])
  1211.         
  1212.         if t == token.LSQB:
  1213.             return self.com_subscriptlist(primaryNode, nodelist[2], OP_APPLY)
  1214.         
  1215.         raise SyntaxError, 'unknown node type: %s' % t
  1216.  
  1217.     
  1218.     def com_select_member(self, primaryNode, nodelist):
  1219.         if nodelist[0] != token.NAME:
  1220.             raise SyntaxError, 'member must be a name'
  1221.         
  1222.         return Getattr(primaryNode, nodelist[1], lineno = nodelist[2])
  1223.  
  1224.     
  1225.     def com_call_function(self, primaryNode, nodelist):
  1226.         if nodelist[0] == token.RPAR:
  1227.             return CallFunc(primaryNode, [], lineno = extractLineNo(nodelist))
  1228.         
  1229.         args = []
  1230.         kw = 0
  1231.         len_nodelist = len(nodelist)
  1232.         for i in range(1, len_nodelist, 2):
  1233.             node = nodelist[i]
  1234.             if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
  1235.                 break
  1236.             
  1237.             (kw, result) = self.com_argument(node, kw)
  1238.             if len_nodelist != 2 and isinstance(result, GenExpr) and len(node) == 3 and node[2][0] == symbol.gen_for:
  1239.                 raise SyntaxError, 'generator expression needs parenthesis'
  1240.             
  1241.             args.append(result)
  1242.         else:
  1243.             i = i + 1
  1244.         if i < len_nodelist and nodelist[i][0] == token.COMMA:
  1245.             i = i + 1
  1246.         
  1247.         star_node = None
  1248.         dstar_node = None
  1249.         while i < len_nodelist:
  1250.             tok = nodelist[i]
  1251.             ch = nodelist[i + 1]
  1252.             i = i + 3
  1253.             if tok[0] == token.STAR:
  1254.                 if star_node is not None:
  1255.                     raise SyntaxError, 'already have the varargs indentifier'
  1256.                 
  1257.                 star_node = self.com_node(ch)
  1258.                 continue
  1259.             if tok[0] == token.DOUBLESTAR:
  1260.                 if dstar_node is not None:
  1261.                     raise SyntaxError, 'already have the kwargs indentifier'
  1262.                 
  1263.                 dstar_node = self.com_node(ch)
  1264.                 continue
  1265.             raise SyntaxError, 'unknown node type: %s' % tok
  1266.         return CallFunc(primaryNode, args, star_node, dstar_node, lineno = extractLineNo(nodelist))
  1267.  
  1268.     
  1269.     def com_argument(self, nodelist, kw):
  1270.         if len(nodelist) == 3 and nodelist[2][0] == symbol.gen_for:
  1271.             test = self.com_node(nodelist[1])
  1272.             return (0, self.com_generator_expression(test, nodelist[2]))
  1273.         
  1274.         if len(nodelist) == 2:
  1275.             if kw:
  1276.                 raise SyntaxError, 'non-keyword arg after keyword arg'
  1277.             
  1278.             return (0, self.com_node(nodelist[1]))
  1279.         
  1280.         result = self.com_node(nodelist[3])
  1281.         n = nodelist[1]
  1282.         while len(n) == 2 and n[0] != token.NAME:
  1283.             n = n[1]
  1284.         if n[0] != token.NAME:
  1285.             raise SyntaxError, "keyword can't be an expression (%s)" % n[0]
  1286.         
  1287.         node = Keyword(n[1], result, lineno = n[2])
  1288.         return (1, node)
  1289.  
  1290.     
  1291.     def com_subscriptlist(self, primary, nodelist, assigning):
  1292.         if len(nodelist) == 2:
  1293.             sub = nodelist[1]
  1294.             if (sub[1][0] == token.COLON or len(sub) > 2 or sub[2][0] == token.COLON) and sub[-1][0] != symbol.sliceop:
  1295.                 return self.com_slice(primary, sub, assigning)
  1296.             
  1297.         
  1298.         subscripts = []
  1299.         for i in range(1, len(nodelist), 2):
  1300.             subscripts.append(self.com_subscript(nodelist[i]))
  1301.         
  1302.         return Subscript(primary, assigning, subscripts, lineno = extractLineNo(nodelist))
  1303.  
  1304.     
  1305.     def com_subscript(self, node):
  1306.         ch = node[1]
  1307.         t = ch[0]
  1308.         if t == token.DOT and node[2][0] == token.DOT:
  1309.             return Ellipsis()
  1310.         
  1311.         if t == token.COLON or len(node) > 2:
  1312.             return self.com_sliceobj(node)
  1313.         
  1314.         return self.com_node(ch)
  1315.  
  1316.     
  1317.     def com_sliceobj(self, node):
  1318.         items = []
  1319.         if node[1][0] == token.COLON:
  1320.             items.append(Const(None))
  1321.             i = 2
  1322.         else:
  1323.             items.append(self.com_node(node[1]))
  1324.             i = 3
  1325.         if i < len(node) and node[i][0] == symbol.test:
  1326.             items.append(self.com_node(node[i]))
  1327.             i = i + 1
  1328.         else:
  1329.             items.append(Const(None))
  1330.         for j in range(i, len(node)):
  1331.             ch = node[j]
  1332.             if len(ch) == 2:
  1333.                 items.append(Const(None))
  1334.                 continue
  1335.             items.append(self.com_node(ch[2]))
  1336.         
  1337.         return Sliceobj(items, lineno = extractLineNo(node))
  1338.  
  1339.     
  1340.     def com_slice(self, primary, node, assigning):
  1341.         lower = None
  1342.         upper = None
  1343.         if len(node) == 3:
  1344.             if node[1][0] == token.COLON:
  1345.                 upper = self.com_node(node[2])
  1346.             else:
  1347.                 lower = self.com_node(node[1])
  1348.         elif len(node) == 4:
  1349.             lower = self.com_node(node[1])
  1350.             upper = self.com_node(node[3])
  1351.         
  1352.         return Slice(primary, assigning, lower, upper, lineno = extractLineNo(node))
  1353.  
  1354.     
  1355.     def get_docstring(self, node, n = None):
  1356.         if n is None:
  1357.             n = node[0]
  1358.             node = node[1:]
  1359.         
  1360.         if n == symbol.suite:
  1361.             if len(node) == 1:
  1362.                 return self.get_docstring(node[0])
  1363.             
  1364.             for sub in node:
  1365.                 if sub[0] == symbol.stmt:
  1366.                     return self.get_docstring(sub)
  1367.                     continue
  1368.             
  1369.             return None
  1370.         
  1371.         if n == symbol.file_input:
  1372.             for sub in node:
  1373.                 if sub[0] == symbol.stmt:
  1374.                     return self.get_docstring(sub)
  1375.                     continue
  1376.             
  1377.             return None
  1378.         
  1379.         if n == symbol.atom:
  1380.             if node[0][0] == token.STRING:
  1381.                 s = ''
  1382.                 for t in node:
  1383.                     s = s + eval(t[1])
  1384.                 
  1385.                 return s
  1386.             
  1387.             return None
  1388.         
  1389.         if n == symbol.stmt and n == symbol.simple_stmt or n == symbol.small_stmt:
  1390.             return self.get_docstring(node[0])
  1391.         
  1392.         if n in _doc_nodes and len(node) == 1:
  1393.             return self.get_docstring(node[0])
  1394.         
  1395.  
  1396.  
  1397. _doc_nodes = [
  1398.     symbol.expr_stmt,
  1399.     symbol.testlist,
  1400.     symbol.testlist_safe,
  1401.     symbol.test,
  1402.     symbol.and_test,
  1403.     symbol.not_test,
  1404.     symbol.comparison,
  1405.     symbol.expr,
  1406.     symbol.xor_expr,
  1407.     symbol.and_expr,
  1408.     symbol.shift_expr,
  1409.     symbol.arith_expr,
  1410.     symbol.term,
  1411.     symbol.factor,
  1412.     symbol.power]
  1413. _cmp_types = {
  1414.     token.LESS: '<',
  1415.     token.GREATER: '>',
  1416.     token.EQEQUAL: '==',
  1417.     token.EQUAL: '==',
  1418.     token.LESSEQUAL: '<=',
  1419.     token.GREATEREQUAL: '>=',
  1420.     token.NOTEQUAL: '!=' }
  1421. _legal_node_types = [
  1422.     symbol.funcdef,
  1423.     symbol.classdef,
  1424.     symbol.stmt,
  1425.     symbol.small_stmt,
  1426.     symbol.flow_stmt,
  1427.     symbol.simple_stmt,
  1428.     symbol.compound_stmt,
  1429.     symbol.expr_stmt,
  1430.     symbol.print_stmt,
  1431.     symbol.del_stmt,
  1432.     symbol.pass_stmt,
  1433.     symbol.break_stmt,
  1434.     symbol.continue_stmt,
  1435.     symbol.return_stmt,
  1436.     symbol.raise_stmt,
  1437.     symbol.import_stmt,
  1438.     symbol.global_stmt,
  1439.     symbol.exec_stmt,
  1440.     symbol.assert_stmt,
  1441.     symbol.if_stmt,
  1442.     symbol.while_stmt,
  1443.     symbol.for_stmt,
  1444.     symbol.try_stmt,
  1445.     symbol.suite,
  1446.     symbol.testlist,
  1447.     symbol.testlist_safe,
  1448.     symbol.test,
  1449.     symbol.and_test,
  1450.     symbol.not_test,
  1451.     symbol.comparison,
  1452.     symbol.exprlist,
  1453.     symbol.expr,
  1454.     symbol.xor_expr,
  1455.     symbol.and_expr,
  1456.     symbol.shift_expr,
  1457.     symbol.arith_expr,
  1458.     symbol.term,
  1459.     symbol.factor,
  1460.     symbol.power,
  1461.     symbol.atom]
  1462. if hasattr(symbol, 'yield_stmt'):
  1463.     _legal_node_types.append(symbol.yield_stmt)
  1464.  
  1465. _assign_types = [
  1466.     symbol.test,
  1467.     symbol.and_test,
  1468.     symbol.not_test,
  1469.     symbol.comparison,
  1470.     symbol.expr,
  1471.     symbol.xor_expr,
  1472.     symbol.and_expr,
  1473.     symbol.shift_expr,
  1474.     symbol.arith_expr,
  1475.     symbol.term,
  1476.     symbol.factor]
  1477. import types
  1478. _names = { }
  1479. for k, v in symbol.sym_name.items():
  1480.     _names[k] = v
  1481.  
  1482. for k, v in token.tok_name.items():
  1483.     _names[k] = v
  1484.  
  1485.  
  1486. def debug_tree(tree):
  1487.     l = []
  1488.     for elt in tree:
  1489.         if type(elt) == types.IntType:
  1490.             l.append(_names.get(elt, elt))
  1491.             continue
  1492.         if type(elt) == types.StringType:
  1493.             l.append(elt)
  1494.             continue
  1495.         l.append(debug_tree(elt))
  1496.     
  1497.     return l
  1498.  
  1499.